import axios from 'axios'
import ElementUI from 'element-ui'
import router from '../router' // 导入router实例

// 创建axios实例
const request = axios.create({
  baseURL: process.env.VUE_APP_API_BASE_URL,
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 防止401错误消息重复显示的标志
let isRefreshing = false;

// 存储正在进行的请求
const pendingRequests = new Map()

// 生成请求唯一标识
function generateRequestKey(config) {
  const { method, url, params, data } = config
  return `${method}-${url}-${JSON.stringify(params || {})}-${JSON.stringify(data || {})}`
}

// 添加请求到队列
function addPendingRequest(config) {
  const requestKey = generateRequestKey(config)
  // 创建取消令牌
  config.cancelToken = config.cancelToken || new axios.CancelToken(cancel => {
    if (!pendingRequests.has(requestKey)) {
      pendingRequests.set(requestKey, cancel)
    }
  })
}

// 移除请求从队列
function removePendingRequest(config) {
  const requestKey = generateRequestKey(config)
  if (pendingRequests.has(requestKey)) {
    // 取消请求
    const cancel = pendingRequests.get(requestKey)
    cancel(`取消重复请求: ${requestKey}`)
    // 移除请求
    pendingRequests.delete(requestKey)
  }
}

// 请求拦截器
request.interceptors.request.use(
  config => {
    // 取消相同的请求
    removePendingRequest(config)
    // 添加当前请求到队列
    addPendingRequest(config)
    
    // 添加token认证
    const token = localStorage.getItem('token')
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`
    }
    return config
  },
  error => {
    return Promise.reject(error)
  }
)

// 响应拦截器
request.interceptors.response.use(
  response => {
    // 请求完成后，从队列中移除
    removePendingRequest(response.config)
    // 统一处理响应数据格式
    
    // 检查响应体中的code字段，处理认证失败的情况
    if (response.data && response.data.code === 401) {
      console.log('响应体中检测到401认证失败');
      // 确保短时间内只显示一个错误消息
      if (!isRefreshing) {
        isRefreshing = true;
        localStorage.removeItem('token');
        try {
          ElementUI.Message.error({message: response.data.msg || '登录已过期，请重新登录', duration: 1000});
        } catch (msgError) {
          console.error('Error showing message:', msgError);
        }
        localStorage.removeItem('userInfo');
        setTimeout(() => {
          router.replace('/login');
          // 重置标志，允许下一次错误消息显示
          setTimeout(() => {
            isRefreshing = false;
          }, 500);
        }, 1500);
      }
      // 返回一个被拒绝的Promise，以便调用者能够捕获这个错误
      return Promise.reject({ message: response.data.msg || '认证失败', isAuthError: true });
    }
    
    return response.data
  },
  error => {
    // 处理错误，如果是取消请求的错误，不显示错误信息
    if (axios.isCancel(error)) {
      console.log('请求已取消:', error.message)
      return Promise.reject({ message: '请求已取消', isCanceled: true })
    }
    
    // 从队列中移除请求
    if (error.config) {
      removePendingRequest(error.config)
    }
    
    // 统一处理错误
    if (error.response) {
      console.log('HTTP错误状态码:', error.response.status);
      switch (error.response.status) {
        // 移除HTTP状态码401的处理，避免与响应体中code为401的处理重复
        case 401:
          // 这个401处理已被移除，避免与响应体中code为401的处理重复显示错误消息
          console.log('HTTP 401检测到，但已由响应体处理');
          break;
        case 403:
          // ElementUI.Message.error({message: '没有权限执行此操作', duration: 1000});
          console.log('HTTP 403检测到，没有权限执行此操作');
          break;
        case 500:
          ElementUI.Message.error({message: '服务器内部错误', duration: 1000});
          console.log('HTTP 500检测到，服务器内部错误');
          break;
        default:
          // ElementUI.Message.error({message: error.response.data.message || '请求失败', duration: 1000});
          console.log('HTTP default error:', error.response.data.message || '请求失败');
      }
    } else if (error.request) {
      // ElementUI.Message.error({message: '网络错误，请检查网络连接', duration: 1000});
      console.log('Network error, no response received'); // 添加调试日志

    } else {
      console.log('Request configuration error:', error.message); // 添加调试日志
      // ElementUI.Message.error({message: '请求配置错误', duration: 1000});
    }
    return Promise.reject(error)
  }
)

export default request